package com.fanshe;

import org.junit.Test;

import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectionTest {

    //反射之前,对Person的操作
    @Test
    public void test1() {


        //1.创建Person类的对象
        Person person = new Person("Tom", 12);

        //2.通过对象，调用其内部的属性和方法
        person.age = 10;
        System.out.println(person.toString());

        person.show();


        //在Person类外部,不可以通过Person类的对象调用其内部私有结构。
        //比如:name, showNation()以及私有的构造器。

    }

    //反射以后，对于Person的操作
    @Test
    public void test2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Class personClass = Person.class;
        //1.通过反射创建Person类的对象
        Constructor constructor = personClass.getConstructor(String.class, int.class);

        Person object = (Person) constructor.newInstance("Tom", 12);

        System.out.println(object);

        //2.通过反射，调用对象指定的属性和方法。

        Field age = personClass.getDeclaredField("age");
        age.set(object, 10);
        System.out.println(object.toString());

        //调用方法
        Method show = personClass.getDeclaredMethod("show");
        show.invoke(object);


        //通过反射，可以调用Person类的私有结构的，比如:私有的构造器，方法，属性。
        //调用私有的构造器
        Constructor cons1 = personClass.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Object object1 = cons1.newInstance("Jerry");
        System.out.println(object1.toString());

        //调用和修改私有的属性
        Field name = personClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(object, "HanMeimei");
        System.out.println(object);

        //调用私有的方法
        Method showNation = personClass.getDeclaredMethod("show", String.class);
        showNation.setAccessible(true);
        Object invoke = showNation.invoke(object1, "中国");
        System.out.println(invoke);
    }

    //疑问：通过直接new的方式或反射的方式，都可以调用公共的结构，开发中到底用哪个？
    //建议直接使用new的方式。
    //什么时候会使用: 反射的方式，反射的特征:动态性
    //疑问?反射机制与面向对象中的封装性是不是矛盾?如何看待两个技术?
    //不矛盾。

    /**
     * 关于java.lang.Class类的理解
     * 1.类的加载过程:
     *      程序在经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)，
     *      接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。
     *      此过程就称为类的加载。 加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。
     *
     * 2.换句话说，Class的实例就对应着一个运行时类。
     *
     * 3.加载到内存中运行时类，会缓存一定的时间，在此时间之内，我们可以通过不同的方式来获取此运行时类。
     *
     *
     *
     */
    //获取Class的实例的方式(前三种方式需要掌握)
    @Test
    public void test3() throws ClassNotFoundException {
        // 方式一: 调用运行时类的属性: .class
        Class personClass = Person.class;
        System.out.println(personClass);

        //方式二: 通过运行时类的对象,调用getClass()
        Person person = new Person();
        Class<? extends Person> aClass = person.getClass();
        System.out.println(aClass);

        //方式三:调用class的静态方法: forName(String classPath)(使用比较多)
        Class<?> aClass1 = Class.forName("com.fanshe.Person");
        System.out.println(aClass1);

        //获取的运行时类都是同一个
        System.out.println(personClass == aClass); //true
        System.out.println(aClass == aClass1);  //true

        //方式四: 使用类的加载器： ClassLoader   (了解)
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class<?> aClass2 = classLoader.loadClass("com.fanshe.Person");
        System.out.println(aClass2);

    }


    //万事万物皆对象!!!!对象.xxx,File,URL,反射,前端,数据库操作。

    //Class实例可以是哪些结构的说明:
    @Test
    public void test4() {
        Class<Object> objectClass = Object.class;
        Class<Comparable> comparableClass = Comparable.class;
        Class<String[]> stringClass = String[].class;
        Class<int[][]> aClass = int[][].class;
        Class<ElementType> elementTypeClass = ElementType.class;
        Class<Override> overrideClass = Override.class;
        Class<Integer> integerClass = int.class;
        Class<Void> voidClass = void.class;
        Class<Class> classClass = Class.class;

        int[] a = new int[10];
        int[] b = new int[100];
        Class<? extends int[]> aClass1 = a.getClass();
        Class<? extends int[]> aClass2 = b.getClass();
        //只要元素类型与维度一样，就是同一个Class
        System.out.println(aClass1 == aClass2);

    }


}
